import java.util.*;
import java.io.*;

class Read {
    /**
     * BFS
     * AB13 【模板】拓扑排序
     * https://www.nowcoder.com/practice/88f7e156ca7d43a1a535f619cd3f495c?tpId=308&tqId=40470&ru=/exam/oj
     */
    // 对字符串进行截取
    StringTokenizer st = new StringTokenizer("");
    // 将 字符流 -> 字节流
    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

    String next() throws IOException {
        while(!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    String nextLine() throws IOException {
        return bf.readLine();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
}

public class day3 {
    public static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    public static Read in = new Read();

    public static int n,m;
    public static Map<Integer,List<Integer>> hash = new HashMap<>(); // 存储图，也就是记录每个数据的出度对应的边
    public static int[] cnt; // 统计入度的数据，也就是个数

    public static void main(String[] args) throws IOException{
        n = in.nextInt();
        m = in.nextInt();
        cnt = new int[n + 1];

        // 1. 建表，并统计每个数据的入度
        for(int i = 0;i < m;i++) {
            int a = in.nextInt(),b = in.nextInt();
            // a -> b
            // 那么就是b的 入度+1
            cnt[b]++;
            if(!hash.containsKey(a)) {
                // 说明 a 这个数据还没有进行记录，创建一个新的
                hash.put(a,new ArrayList<>());
            }
            // 把a->b 的关系建立起来
            hash.get(a).add(b);
        }
        // 2.创建队列，并且把入度为0 的点入队
        Queue<Integer> queue = new LinkedList<>();
        for(int i = 1;i <= n;i++) {
            if(cnt[i] == 0) {
                // 入度为0的点
                queue.add(i);
            }
        }
        int[] ret = new int[n];
        int pos = 0;
        // 3. 处理队列，并且处理 建立的图的关系，将其去除边，并且把对应的入度进行减小
        while(!queue.isEmpty()) {
            // 出队
            int t = queue.poll();
            // 放入到返回数组中
            ret[pos++] = t;
            // 处理建立的图 和 入度的值
            for(int b : hash.getOrDefault(t,new ArrayList<>())) {
                // b这个值的入度减小
                cnt[b]--;
                // 如果这个b的入度为0，就将其放入到队列中
                if(cnt[b] == 0) {
                    queue.add(b);
                }
            }
        }
        // 4. 处理完队列之后，判断这个 拓扑排序 是否存在环
        if(pos == n) {
            // 无环
            // 最后一个数的后面没有空格
            for(int i = 0;i < n - 1;i++) {
                out.print(ret[i] + " ");
            }
            out.println(ret[n - 1]);
        }else {
            out.print(-1);
        }

        out.close();
    }


    /**
     * 枚举 + 二分
     * 分组
     * https://ac.nowcoder.com/acm/problem/229023
     */
    static int n1;
    static int m1;
    static Map<Integer,Integer> hash1 = new HashMap<>();
    public static void main2(String[] args) {
        Scanner in = new Scanner(System.in);
        n1 = in.nextInt();
        m1 = in.nextInt();
        // 如果拿着每个声部的人数去分组的话，那么是不对的，因为不知每组分多少个人，分成几组
        // 1.所以利用 正难则反 的思想，从 1~hmax(所有声部对应的人数中最大值) 去枚举每组分配的人数，进而进行按人数进行分组，
        //   当所有 声部都分完组之后，所有组数之和小于等于m这个值，那么这个人数即表示人数最多的小组的人数

        // 1.先进行统计每个声部的对应的人数，并且统计hmax
        int hmax = 0;
        for(int i = 0;i < n1;i++) {
            int x = in.nextInt();
            hash1.put(x,hash1.getOrDefault(x,0) + 1);
            if(hash1.get(x) > hmax) {
                hmax = hash1.get(x);
            }
        }
        // 2.判断一下hash中的个数，也就是声部的种类如果大于m的话，那么就不能正常分组
        int kinds = hash1.size();
        if(kinds > m1) {
            System.out.println(-1);
        }else {
            //暴力枚举
//             for(int i = 1;i <= hmax;i++) {
//                 if(check(i)) {
//                     System.out.println(i);
//                     break;
//                 }
//             }
            // 二分查找 —— 优化
            int left = 1,right = hmax;
            while(left < right) {
                int mid = (left + right) / 2;
                if(check(mid)) {
                    right = mid;
                }else {
                    left = mid + 1;
                }
            }
            System.out.print(left);
        }
    }

    public static boolean check(int x) {
        //这里的x 表示为每组的人数
        int count = 0;
        for(int a : hash1.values()) {
            count += a / x + (a % x == 0 ? 0 : 1);
        }
        return count <= m;
    }


    /**
     * 数学
     * 平方数
     * https://ac.nowcoder.com/acm/problem/205350
     */
    public static void main1(String[] args) {
        Scanner in = new Scanner(System.in);
        long x = in.nextLong();
        // 1.对输入的数据 x 进行开根号，对其数据取整操作
        long a = (long) Math.sqrt(x);
        // 2. 那么 x 开根号的数就在 a ~ a+1 区间的一个数
        // 3. 对 a 和 a+1 都进行求取平方，得到的就是 离x这个数最近的左右两个平方数
        long y1 = a * a,y2 = (a + 1) * (a + 1);
        // 4. 求取 谁的差值小即可
        if(x - y1 < y2 - x) {
            System.out.println(y1);
        }else {
            System.out.println(y2);
        }
    }
}
